home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 4: GNU Archives / Linux Cubed Series 4 - GNU Archives.iso / gnu / fontutil.6 / fontutil / fontutils-0.6 / limn / curve.h < prev    next >
Encoding:
C/C++ Source or Header  |  1992-10-05  |  5.2 KB  |  158 lines
  1. /* curve.h: data structures for the conversion from pixels to splines.
  2.  
  3. Copyright (C) 1992 Free Software Foundation, Inc.
  4.  
  5. This program is free software; you can redistribute it and/or modify
  6. it under the terms of the GNU General Public License as published by
  7. the Free Software Foundation; either version 2, or (at your option)
  8. any later version.
  9.  
  10. This program is distributed in the hope that it will be useful,
  11. but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. GNU General Public License for more details.
  14.  
  15. You should have received a copy of the GNU General Public License
  16. along with this program; if not, write to the Free Software
  17. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  18.  
  19. #ifndef CURVE_H
  20. #define CURVE_H
  21.  
  22. #include "types.h"
  23. #include "vector.h"
  24.  
  25.  
  26. /* We are simultaneously manipulating two different representations of
  27.    the same outline: one based on (x,y) positions in the plane, and one
  28.    based on parametric splines.  (We are trying to match the latter to
  29.    the former.)  Although the original (x,y)'s are pixel positions,
  30.    i.e., integers, after filtering they are reals.  */
  31.  
  32. typedef struct
  33. {
  34.   real_coordinate_type coord;
  35.   real t;
  36. } point_type;
  37.  
  38.  
  39. /* It turns out to be convenient to break the list of all the pixels in
  40.    the outline into sublists, divided at ``corners''.  Then each of the
  41.    sublists is treated independently.  Each of these sublists is a `curve'.  */
  42.  
  43. struct curve
  44. {
  45.   point_type *point_list;
  46.   int length;
  47.   boolean cyclic;
  48.   vector_type *start_tangent;
  49.   vector_type *end_tangent;
  50.   struct curve *previous;
  51.   struct curve *next;
  52. };
  53.  
  54. typedef struct curve *curve_type;
  55.  
  56. /* Get at the coordinates and the t values.  */
  57. #define CURVE_POINT(c, n) ((c)->point_list[n].coord)
  58. #define LAST_CURVE_POINT(c) ((c)->point_list[(c)->length-1].coord)
  59. #define CURVE_T(c, n) ((c)->point_list[n].t)
  60. #define LAST_CURVE_T(c) ((c)->point_list[(c)->length-1].t)
  61.  
  62. /* This is the length of `point_list'.  */
  63. #define CURVE_LENGTH(c)  ((c)->length)
  64.  
  65. /* A curve is ``cyclic'' if it didn't have any corners, after all, so
  66.    the last point is adjacent to the first.  */
  67. #define CURVE_CYCLIC(c)  ((c)->cyclic)
  68.  
  69. /* If the curve is cyclic, the next and previous points should wrap
  70.    around; otherwise, if we get to the end, we return CURVE_LENGTH and
  71.    -1, respectively.  */
  72. #define CURVE_NEXT(c, n)                        \
  73.   ((n) + 1 >= CURVE_LENGTH (c)                        \
  74.   ? CURVE_CYCLIC (c) ? ((n) + 1) % CURVE_LENGTH (c) : CURVE_LENGTH (c)    \
  75.   : (n) + 1)
  76. #define CURVE_PREV(c, n)                        \
  77.   ((int) (n) - 1 < 0                            \
  78.   ? CURVE_CYCLIC (c) ? CURVE_LENGTH (c) + (int) (n) - 1 : -1        \
  79.   : (int) (n) - 1)
  80.  
  81. /* The tangents at the endpoints are computed using the neighboring curves.  */
  82. #define CURVE_START_TANGENT(c) ((c)->start_tangent)
  83. #define CURVE_END_TANGENT(c) ((c)->end_tangent)
  84. #define PREVIOUS_CURVE(c) ((c)->previous)
  85. #define NEXT_CURVE(c) ((c)->next)
  86.  
  87.  
  88. /* Return an entirely empty curve.  */
  89. extern curve_type new_curve (void);
  90.  
  91. /* Return a curve with the point P as its first element.  */
  92. extern curve_type init_curve (coordinate_type p);
  93.  
  94. /* Return a curve the same as C, except without any points.  */
  95. extern curve_type copy_most_of_curve (curve_type c);
  96.  
  97. /* Free the memory C uses.  */
  98. extern void free_curve (curve_type c);
  99.  
  100. /* Append the point P to the end of C's list.  */
  101. extern void append_pixel (curve_type c, coordinate_type p);
  102.  
  103. /* Like `append_pixel', for a point in real coordinates.  */
  104. extern void append_point (curve_type c, real_coordinate_type p);
  105.  
  106. /* Write some or all, respectively, of the curve C in human-readable
  107.    form to the log file, if logging is enabled.  */
  108. extern void log_curve (curve_type c, boolean print_t);
  109. extern void log_entire_curve (curve_type c);
  110.  
  111. /* Display the curve C online, if displaying is enabled.  */
  112. extern void display_curve (curve_type);
  113.  
  114. /* So, an outline is a list of curves.  */
  115. typedef struct
  116. {
  117.   curve_type *data;
  118.   unsigned length;
  119.   boolean clockwise;
  120. } curve_list_type;
  121.  
  122. /* Number of curves in the list.  */
  123. #define CURVE_LIST_LENGTH(c_l)  ((c_l).length)
  124.  
  125. /* Access the individual curves.  */
  126. #define CURVE_LIST_ELT(c_l, n) ((c_l).data[n])
  127. #define LAST_CURVE_LIST_ELT(c_l) ((c_l).data[CURVE_LIST_LENGTH (c_l) - 1])
  128.  
  129. /* Says whether the outline that this curve list represents moves
  130.    clockwise or counterclockwise.  */
  131. #define CURVE_LIST_CLOCKWISE(c_l) ((c_l).clockwise)
  132.  
  133.  
  134. extern curve_list_type new_curve_list (void);
  135. extern void free_curve_list (curve_list_type *);
  136. extern void append_curve (curve_list_type *, curve_type);
  137.  
  138. /* And a character is a list of outlines.  I named this
  139.    `curve_list_array_type' because `curve_list_list_type' seemed pretty
  140.    monstrous.  */
  141. typedef struct
  142. {
  143.   curve_list_type *data;
  144.   unsigned length;
  145. } curve_list_array_type;
  146.  
  147. /* Turns out we can use the same definitions for lists of lists as for
  148.    just lists.  But we define the usual names, just in case.  */
  149. #define CURVE_LIST_ARRAY_LENGTH CURVE_LIST_LENGTH
  150. #define CURVE_LIST_ARRAY_ELT CURVE_LIST_ELT
  151. #define LAST_CURVE_LIST_ARRAY_ELT LAST_CURVE_LIST_ELT
  152.  
  153. extern curve_list_array_type new_curve_list_array (void);
  154. extern void free_curve_list_array (curve_list_array_type *);
  155. extern void append_curve_list (curve_list_array_type *, curve_list_type);
  156.  
  157. #endif /* not CURVE_H */
  158.